package DataStructure_ZL.集合重构;

import java.util.Arrays;

public class DemoArrayList {
    int[] arr={};
    private int pos=-1;//记录数组元素的个数
    public static final int MR_SIZE=3;//默认的数组大小
    //生成构造方法
    //无参
    public DemoArrayList(){
        arr=new int[MR_SIZE];
    }
    //有参构造,用户传一个数组的大小值
    public DemoArrayList(int UsedSize){
        if (UsedSize>0){
            arr=new int[UsedSize];
        }else{
            throw new IllegalArgumentException("数组大小不能为0或负数");
        }
    }

    // 打印顺序表
    public void display() {
        if(this.pos<0){
            throw new IllegalArgumentException("集合为空");
        }
        for (int i = 0; i <= pos; i++) {
            System.out.println(arr[i]);
        }
    }
    //判断数组是不是满的
    public boolean isFull(){
        return pos<arr.length-1;
    }
    //对数组进行扩容
    public void Expansion(){
        arr= Arrays.copyOf(arr,arr.length*2);
    }
    // 新增元素,默认在数组最后新增
    public void add(int data/*用户输入的数据*/) {
        if (isFull()){
            arr[pos+1]=data;
        }else{
            //数组满了，调用扩容机制
            Expansion();
            add(data);
            //因为再次调用了这个方法所以pos会自增两次但是只添加了一个元素所以要自减一次
            pos--;
        }
        pos++;
    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        //先判断是不是满的然后再添加元素，添加时候从后面往前面进行添加，当后面的索引小于pos就停止
        if (this.pos == arr.length - 1) {//说明数组已经满了
            Expansion();//扩容
        }
        if (pos < 0 || pos > this.pos + 1 ) {
            //超出数组索引
            throw new IllegalArgumentException("索引错误");
        }
        if (pos==this.pos+1&&pos<arr.length){//说明用户传的索引刚好是数组最后且小于或等于数组的最大索引
            add(data);
            return;//添加元素后退出方法
        }

        //经过上面三个if的筛选总的是剩下用户的索引刚好在有元素的位置
        for (int i = this.pos; i>=pos; i--) {
            arr[i+1]=arr[i];
        }
        //经过for循环后要插入的索引位置已经空了直接插入数据
        arr[pos]=data;
        this.pos++;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i <=pos ; i++) {
            if (arr[i]==toFind){
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i <=pos ; i++) {
            if (arr[i] == toFind) {
                return i;
            }
        }
            return -1;

    }
    // 获取 pos 位置的元素
    public int get(int pos) {
        if (pos>=0&&pos<=this.pos){
            return arr[pos];
        }else{
            throw new IllegalArgumentException("集合没有该索引");
        }
    }
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        if(this.pos<0) {//pos为空说明集合还没有任何元素
            throw new IllegalArgumentException("顺序表为空，不能删除！");
        }
        if (pos>=0&&pos<=this.pos){
            arr[pos]=value;
        }else{
            throw new IllegalArgumentException("集合没有该索引");
        }
    }
    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(this.pos<0) {//pos为空说明集合还没有任何元素
            throw new IllegalArgumentException("顺序表为空，不能删除！");
        }
        int index=indexOf(toRemove);//获取toRemove元素所在的索引没有就会返回-1
        if (index<0){
            System.out.println("不存在你要删除的元素");
            return ;
        }
        for (int i = index; i<this.pos; i++) {//i不能取到数组的最后一位，因为当取到最后一位时下面的i+1会索引越界
            arr[i]=arr[i+1];
            arr[pos]=0 ;
        }
        this.pos--;
    }
    // 获取顺序表长度
    public int size() { return this.pos+1; }
    // 清空顺序表
    public void clear() {
        arr=new int[0];
    }
}
